package com.sumainfor.pc.market.service;

import com.alibaba.fastjson.JSON;
import com.sumainfor.common.util.*;
import com.sumainfor.common.utlis.PageUtils;
import com.sumainfor.common.utlis.Pager;
import com.sumainfor.common.utlis.ParamsCommon;
import com.sumainfor.pc.market.dao.*;
import com.sumainfor.pc.market.feign.Zfeign.ZpcEpcFeign;
import com.sumainfor.pc.market.feign.Zfeign.ZzuulFeign;
import org.apache.commons.collections.MapUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.interceptor.TransactionAspectSupport;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.locks.ReentrantLock;

/**
 * @Date 2018年11月7日
 * @Describe 工程部查询房源配置
 */
@Service
public class RdHousingInfoService implements Serializable {

    private ReentrantLock lock = new ReentrantLock(false);

    Logger log = LoggerFactory.getLogger(RdHousingInfoService.class);// 日志

    @Autowired
    private RdHousingInfoMapper rdHousingInfoMapper;
    @Autowired
    private RdHousingConMapper rdHousingConMapper;
    @Autowired
    private RdHousingConInfoMapper rdHousingConInfoMapper;
    @Autowired
    private RdHousingMapper rdHousingMapper;
    @Autowired
    private RdTenantMapper rdTenantMapper;
    @Autowired
    private ZzuulFeign zzuulFeign;
    @Autowired
    private ZpcEpcFeign zpcEpcFeign;
    @Autowired
    private RdHousingShelfMapper rdHousingShelfMapper;
    /**
     * 根据房源主表编号查询整套房源的房间信息
     */
    public List<Map<String,Object>> getHousingHouInfoIdAllByHouId(Map<String,Object> params){
        List<Map<String,Object>> list=rdHousingInfoMapper.getHousingHouInfoIdAllByHouId(params);
        JsonResult zepcResult=zpcEpcFeign.getHoRdHpiList(params);
        if (zepcResult.get("errorCode").toString().equals("0")) {
            List<Map<String, Object>> zepcList = (List<Map<String, Object>>) zepcResult.get("result");
            for (Map<String, Object> map1 : list) {
                if (map1.get("HouConId") != null) {
                    for (Map<String, Object> map2 : zepcList) {
                        if (map2.get("HouConId") != null) {
                            if (map1.get("HouConId").toString().equals(map2.get("HouConId").toString())) {
                                map1.putAll(map2);
                            }
                        }
                    }
                }
            }
        }
        return list;
    }
    /**
     * 查询一套房源的每个房间的下拉列表
     */
    public List<Map<String,Object>> getHousingInfoListByHouInfoId(Map<String,Object> params){
        return  rdHousingInfoMapper.getHousingInfoListByHouInfoId(params);
    }
    /**
     * 根据房间id查询对应房间的信息
     */
    public Map<String,Object>  getHousingInfoByHouInfoId(Map<String,Object> params){
        Map<String,Object> map=rdHousingInfoMapper.getHousingInfoByHouInfoId(params);
        //查询房源主表的图片
        Map<String,Object> houImageMap=rdHousingMapper.getHouImageByHouIdForPact(map);
        if (houImageMap!=null){
            map.putAll(houImageMap);
        }
        if(map.get("ProOperaType").toString().equals("1")){//盈利预测房源租赁类型 1.合租 2.整租
            System.out.println("IfOperaType:"+map.get("IfOperaType").toString());
            if(map.get("IfOperaType").toString().equals("0")){//是否是整租 0否 1是\
                System.out.println("IfOperaTy1111pe");
                List<Map<String,Object>> imgList=rdHousingInfoMapper.getHouInfoImageByHouInfoId(map);
                if (imgList!=null && imgList.size()>0){
                    map.put("HiList",imgList);
                }else{
                    map.put("HiList",new ArrayList<Map<String,Object>>());
                }

            }else{//整租
                System.out.println("IfOperaTy1111pe222");
                List<Map<String,Object>> imgList=rdHousingInfoMapper.getHouInfoImageByHouInfoId(map);
                if (imgList!=null && imgList.size()>0){
                    map.put("HiList",imgList);
                }else{
                    map.put("HiList",new ArrayList<Map<String,Object>>());
                }
            }
        }else{//整租
            List<Map<String,Object>> imgList=rdHousingInfoMapper.getHouInfoImageByHouInfoId(map);
            if (imgList!=null && imgList.size()>0){
                map.put("HiList",imgList);
            }else{
                map.put("HiList",new ArrayList<Map<String,Object>>());
            }
        }
        //传递到网关的服务管家编号，和所属服务中心编号
        if(map.get("SysUserId")!=null){
            params.put("user_id",map.get("SysUserId"));
        }
        if(map.get("MiId")!=null){
            params.put("dept_id",map.get("MiId"));
        }
        JsonResult zuulMap = zzuulFeign.getUserDeptName(params);
        System.out.println("网关返回的值:"+zuulMap);
        if (zuulMap.get("errorCode").equals("0")) {
            Map<String,Object> resultMap=(Map<String, Object>) zuulMap.get("result");
            map.putAll(resultMap);
        }
        return map;
    }
    /**
     * 根据房源主表编号查询整套房源的房间信息
     */
    public JsonResult getHousingHouInfoIdByHouConId(Map<String,Object> params){

        JsonResult result=new JsonResult();
        if (params.get("HouId")==null){
            return  result.putFailed("参数不正确");
        }
        //查询房间编号对应的信息
        Map<String,Object>  map=rdHousingInfoMapper.getHousingHouInfoIdAllByHouInfoId(params);
        //查询整租的房源所包含的房间是否有存在异常
        if(params.get("IfOperaType").toString().equals("1")) {//房源租赁类型 0.合租 1.整租
            Integer count = rdHousingInfoMapper.getAbnormalCount(params);
            System.out.println("count:"+count);
            if (count != null) {
                map.put("AbnCount", count);
            } else {
                map.put("AbnCount", 0);
            }
        }else{
            map.put("AbnCount", 0);
        }
        JsonResult zepcResult=zpcEpcFeign.getHoPlanAlterList(params);
        System.out.println(zepcResult);
        if (zepcResult.get("errorCode").toString().equals("0")){
            List<Map<String,Object>> zepcList=(List<Map<String,Object>>)zepcResult.get("result");
            List<Map<String,Object>> maeketList= rdHousingConMapper.getRdHonConList(params);
            for (Map<String,Object> map1:zepcList){
                if (map1.get("HouConId")!=null){
                    for (Map<String,Object> map2:maeketList){
                        if (map2.get("HouConId")!=null){
                            if (map1.get("HouConId").toString().equals(map2.get("HouConId").toString())){
                                map1.putAll(map2);
                            }
                        }
                    }
                }
            }
            if (zepcList!=null){
                map.put("HiList", zepcList);
            }else {
                map.put("HiList", new ArrayList<Map<String,Object>>());
            }
        }else{
            return zepcResult;
        }
        if (map!=null){
            result.put(map);
        }else{
            result.putFailed("服务器繁忙");
        }
        return result;
    }
    /*
     *房源上架
     */
    @Transactional(rollbackFor = Exception.class)
    public JsonResult updateHousingHouInfo(Map<String,Object> params){
        JsonResult result=new JsonResult();
        /**
         * 加锁操作
         */
        lock.lock();
        try{
            try {
                if(params.get("HouInfoId")==null || params.get("sameCityCount")==null || params.get("SheTypeList")==null
                    || params.get("HouId")==null || params.get("IfOperaType")==null || params.get("thState")==null){
                    return result.putFailed("参数不正确");
                }
                boolean ifsameCity=false;//是否要推送房源到58
                Integer sameCityCount=(Integer)params.get("sameCityCount");//58 是否已经发布
                //选中的第三方平台集合
                List<Integer> sheTypeList=(List<Integer>)params.get("SheTypeList");
                for (Integer sheType :sheTypeList){
                    //sheType 0  58同城 1 贝壳
                    if (sheType!=null & sheType.toString().equals("0")){
                        ifsameCity=true;
                    }
                }
                //组装第三方上架信息
                Map<String,Object> rdHsMap=new HashMap<String, Object>();
                rdHsMap.put("SheId",UUIDUtils.generateShortUuid());//主键编号
                rdHsMap.put("HouId",params.get("HouId"));//房源主表编号
                rdHsMap.put("IfOperaType",params.get("IfOperaType"));//是否是整租 0否 1是
                rdHsMap.put("HouInfoId",params.get("HouInfoId"));//房源详表编号
                rdHsMap.put("AddedId",ContextUtils.getUserId());//上架人
                rdHsMap.put("by", ContextUtils.getUserId());//操作人
                rdHsMap.put("term", "2");// 更新端 Update端： 1 租客端 2市场部 3 工程部   4运营部   5财务部  6总经办 7发展部
                rdHsMap.put("fnc",
                        this.getClass().getSimpleName() + "." + Thread.currentThread().getStackTrace()[1].getMethodName());// 创建Function名
                ParamsCommon.commonUpdateParms(rdHsMap);
                rdHsMap.put("AddedTime",rdHsMap.get("instm"));//上架时间
                //组装修改房源信息
                params.put("State",1);//房源状态0 可预销 1可签约 2已签约
                if (String.valueOf(params.get("thState")).equals("7")){
                    params.put("HouState","2");//预销状态（0 不能预销 1可以预销 2 可签约）
                }else if(String.valueOf(params.get("HouState")).equals("0")){
                    params.put("HouState","2");//预销状态（0 不能预销 1可以预销 2 可签约）
                }
                params.put("by", ContextUtils.getUserId());//操作人
                params.put("term", "2");// 更新端 Update端： 1 租客端 2市场部 3 工程部   4运营部   5财务部  6总经办 7发展部
                params.put("fnc",
                        this.getClass().getSimpleName() + "." + Thread.currentThread().getStackTrace()[1].getMethodName());// 创建Function名
                ParamsCommon.commonUpdateParms(params);
                params.put("ShelfId",ContextUtils.getUserId());//房源上架人编号
                params.put("AddedTime",params.get("updtm"));//房源上架时间
                Integer count=rdHousingInfoMapper.updateHousingHouInfo(params);
                if (count!=null && count>0){
                    //如果需要推送房源到58同城
                    if (ifsameCity==true){
                        //组装请求接口的map类型参数
                        Map<String,Object> dataMap=new HashMap<String,Object>();
                        dataMap.put("appId", InteSameCityConfig.APPID_TEST);
                        // dataMap.put("videoUrl","1");//合作公寓系统的房屋视频url (N)
                        List<String> list = new ArrayList<String>();
                        list.add("http://pic.58.com/manage.yuefu.58.com/n_v1bkujjd2aw5xfmf3qzyeq_cdebc1e04c8f0db9.jpg");
                        list.add("http://pic.58.com/manage.yuefu.58.com/n_v1bkujjd2aw5xfmf3qzyeq_cdebc1e04c8f0db9.jpg");
                        list.add("http://pic.58.com/manage.yuefu.58.com/n_v1bkujjd2aw5xfmf3qzyeq_cdebc1e04c8f0db9.jpg");
                        list.add("http://pic.58.com/manage.yuefu.58.com/n_v1bkujjd2aw5xfmf3qzyeq_cdebc1e04c8f0db9.jpg");
                        list.add("http://pic.58.com/manage.yuefu.58.com/n_v1bkujjd2aw5xfmf3qzyeq_cdebc1e04c8f0db9.jpg");
                        list.add("http://pic.58.com/manage.yuefu.58.com/n_v1bkujjd2aw5xfmf3qzyeq_cdebc1e04c8f0db9.jpg");
                        dataMap.put("picUrlList", list);
                        dataMap.put("rentType","1");//1.整套出租 2.单间出租
                        dataMap.put("bedRoomNum","2");//房屋户型-室例如（2室）：2
                        dataMap.put("livingRoomNum","1");//房屋户型-厅例如（1室）：1  可以为0
                        dataMap.put("toiletNum","1");//房屋户型-卫 例如（1卫）：1  可以为0
                        dataMap.put("rentRoomArea","110");//对于单间出租的，为出租间面积 对于整租的为房屋总面积 对于整租的为房屋总面积 例如：110
                        dataMap.put("bedRoomType","31");//出租屋类型，枚举值。 出租屋类型，枚举值。
                        dataMap.put("faceToType","60");//faceToType 60:东 61:南 62:西63:北
                        dataMap.put("totalFloor","18");//totalFloor
                        dataMap.put("houseFloor","5");//房间所在楼层
                        // dataMap.put("featureTag","10");//房间所在楼层 (N)
                        dataMap.put("detailPoint","71");//房屋配置，枚举值，可多选
                        //        dataMap.put("servicePoint","91");//公寓配套服务，枚举值，可多选 (N)
                        dataMap.put("monthRent","2100");//月租金，以元为单位
                        dataMap.put("rentStartDate","2015-12-31");//起租时间，格式yyyy-MM-dd
                        dataMap.put("shortRent","0");//是否支持短租，枚举值0:不支持 1支持 (N)
                        //        dataMap.put("shotRentCycle","10");//选择短租模式，此字段必填 (N)
                        //        dataMap.put("shotRentPrice","10");//短租价格 (N)
                        dataMap.put("cityName","北京");//所在城市 上海
                        dataMap.put("countyName","朝阳区");//所在区县 浦东
                        dataMap.put("areaName","甜水园");//房屋所在商圈 高行
                        dataMap.put("districtName","成熟小区");//districtName 新高苑
                        dataMap.put("street","距14号线朝阳公园约706米");//房屋所在小区详细地址
                        dataMap.put("address","8楼102");//房屋所在小区详细地址

                        dataMap.put("houseDesc","唐巢高科坊集中式公寓 位于高科东路1870号\n" +
                                "\n" +
                                "独立一居室（独立厨房、卫生间）高端大气上档次\n" +
                                "\n" +
                                "一、配套成熟——门口有多家餐饮连锁店，周边超市等生活配套设施齐全，能够充分满足您一站式购物需要，是您理想的居家场所。\n" +
                                "\n" +
                                "二、交通便利——门店公交众多，交通四通八达，您想到上海的任何一个角落都是相当方便。\n" +
                                "\n" +
                                "三、品质精装——给所有住户匹配的空间尺度、品牌家具组合、简约宜家风设计。实现简约、自然、有设计感的宜居空间。\n" +
                                "\n" +
                                "四、多样房型——户型设计紧凑,多功能馈赠空间；在有限空间实现了居住梦想的放大。每间房间阳光无遮挡。视野开阔，让您的居家生活丰富多彩。\n" +
                                "\n" +
                                "五、专业管理——24小时全方位的监控系统、出入口电子门禁系统，高安全保障，使您住的放心！\n" +
                                "\n" +
                                "六、增值服务——每日都会有公寓管家值班，随时为您服务（如代收快递等），并且还有定期举行公寓活动，享受真正的“喜欢你的生活”。\n" +
                                "\n" +
                                "七、专业保洁——每天都会有保洁阿姨打扫公共走廊的卫生，在公寓多个角落都有摆放的环保大垃圾桶，省了您到外面丢垃圾的烦恼，为能保持您室内空气清新多一份保证。\n" +
                                "\n" +
                                "欢迎有意向的小伙伴前来咨询~");//房屋所在小区详细地址
                        dataMap.put("xCoord","116.48056");//房屋所在小区详细地址
                        dataMap.put("yCoord","39.930321");//房屋所在小区详细地址
                        dataMap.put("agentPhone","15703928852");//房屋所在小区详细地址
                        dataMap.put("agentName","10");//房屋所在小区详细地址
                        //        dataMap.put("paymentMode","10");//支付方式 (N)
                        //        dataMap.put("rentRequire","10");//入住要求 (N)
                        //dataMap.put("hasLift ","1");//电梯：1 无电梯 2 有电梯 (N)
                        Map<String,Object> sameShellResult;
                        if (sameCityCount==0){//sameCityCount 0未发布 1已发布
                            //是否是整租 0否 1是
                            if (params.get("IfOperaType").toString().equals("1")){
                                dataMap.put("outHouseId",params.get("HouId"));
                            }else{
                                dataMap.put("outHouseId",params.get("HouInfoId"));
                            }
                            //请求体
                            Map<String,String> map=new HashMap<String,String>();
                            //组装请求接口的map类型参数 转成json 然后生成加密字符串
                            String rsaString= ThirdRSACoder.encrypt(JSON.toJSONString(dataMap),InteSameCityConfig.PRIVATE_KEY);
                            log.info("rsaString:"+rsaString);
                            log.info("rsaString2:"+ThirdRSACoder.decrypt(rsaString,InteSameCityConfig.PUBLIIC_KEY));
                            map.put("data",rsaString);
                            //第一次发布房源到58
                            sameShellResult=InteSameCityUtil.api_house_add(map);
                            log.info("内部房源在58发布返回的参数:"+sameShellResult);
                        }else{
                            dataMap.put("houseId",params.get("stPrimaryKey"));
                            //请求体
                            Map<String,String> map=new HashMap<String,String>();
                            //组装请求接口的map类型参数 转成json 然后生成加密字符串
                            String rsaString= ThirdRSACoder.encrypt(JSON.toJSONString(dataMap),InteSameCityConfig.PRIVATE_KEY);
                            log.info("rsaString:"+rsaString);
                            log.info("rsaString2:"+ThirdRSACoder.decrypt(rsaString,InteSameCityConfig.PUBLIIC_KEY));
                            map.put("data",rsaString);
                            //如果该房源在58平台已经发布的话就做修改操作
                            sameShellResult=InteSameCityUtil.api_house_modify(map);
                            log.info("修改内部房源在58的房源信息返回的参数:"+sameShellResult);
                        }

                        if(sameShellResult.get("code")!=null && sameShellResult.get("code").toString().equals("0")){
                            Map<String,Object> sameSheMap=(Map<String,Object>)sameShellResult.get("result");
                            rdHsMap.put("PrimaryStatus","1");//第三方上架状态 0 待上架 1可签约 2已签约
                            rdHsMap.put("PrimaryKey",sameSheMap.get("houseId")) ;//58返回的房源编号
                            rdHousingShelfMapper.addRdHs(rdHsMap);//新增内部房源在58平台的房源信息
                            result.putSuccess("上架成功");
                        }else{
                            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                            result.putFailed("服务器繁忙");
                        }
                    }
                    result.putSuccess("上架成功");
                }else{
                    TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                    result.putFailed("服务器繁忙");
                }
            } catch (Exception e) {
                e.printStackTrace();
                TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            }
        }
        finally {
            lock.unlock();
        }
        return result;
    }
//
//    /*
//     *房源上架
//     */
//    @Transactional(rollbackFor = Exception.class)
//    public JsonResult updateHousingHouInfo(Map<String,Object> params){
//        JsonResult result=new JsonResult();
//        /**
//         * 加锁操作
//         */
//        lock.lock();
//        try{
//            try {
//                if(params.get("HouInfoId")==null || params.get("sameCityCount")==null || params.get("SheTypeList")==null
//                        || params.get("HouId")==null || params.get("IfOperaType")==null){
//                    return result.putFailed("参数不正确");
//                }
//                boolean ifsameCity=false;//是否要推送房源到58
//                Integer sameCityCount=(Integer)params.get("sameCityCount");//58 是否已经发布
//                //选中的第三方平台集合
//                List<Integer> sheTypeList=(List<Integer>)params.get("SheTypeList");
//                for (Integer sheType :sheTypeList){
//                    //sheType 0  58同城 1 贝壳
//                    if (sheType!=null & sheType.toString().equals("0")){
//                        ifsameCity=true;
//                    }
//                }
//                //组装第三方上架信息
//                Map<String,Object> rdHsMap=new HashMap<String, Object>();
//                rdHsMap.put("SheId",UUIDUtils.generateShortUuid());//主键编号
//                rdHsMap.put("HouId",params.get("HouId"));//房源主表编号
//                rdHsMap.put("IfOperaType",params.get("IfOperaType"));//是否是整租 0否 1是
//                rdHsMap.put("HouInfoId",params.get("HouInfoId"));//房源详表编号
//                rdHsMap.put("AddedId",ContextUtils.getUserId());//上架人
//                rdHsMap.put("by", ContextUtils.getUserId());//操作人
//                rdHsMap.put("term", "2");// 更新端 Update端： 1 租客端 2市场部 3 工程部   4运营部   5财务部  6总经办 7发展部
//                rdHsMap.put("fnc",
//                        this.getClass().getSimpleName() + "." + Thread.currentThread().getStackTrace()[1].getMethodName());// 创建Function名
//                ParamsCommon.commonUpdateParms(rdHsMap);
//                rdHsMap.put("AddedTime",rdHsMap.get("instm"));//上架时间
//                //组装修改房源信息
//                params.put("State",1);//房源状态0 可预销 1可签约 2已签约
//                params.put("by", ContextUtils.getUserId());//操作人
//                params.put("term", "2");// 更新端 Update端： 1 租客端 2市场部 3 工程部   4运营部   5财务部  6总经办 7发展部
//                params.put("fnc",
//                        this.getClass().getSimpleName() + "." + Thread.currentThread().getStackTrace()[1].getMethodName());// 创建Function名
//                ParamsCommon.commonUpdateParms(params);
//                params.put("ShelfId",ContextUtils.getUserId());//房源上架人编号
//                params.put("AddedTime",params.get("updtm"));//房源上架时间
//                Integer count=rdHousingInfoMapper.updateHousingHouInfo(params);
//                if (count!=null && count>0){
//                    //如果需要推送房源到58同城
//                    if (ifsameCity==true){
//                        //组装请求接口的map类型参数
//                        Map<String,Object> dataMap=new HashMap<String,Object>();
//                        dataMap.put("appId", InteSameCityConfig.APPID_TEST);
//                        // dataMap.put("videoUrl","1");//合作公寓系统的房屋视频url (N)
//                        //组装房源图片
//                        List<String> list= new ArrayList<String>();
//                        if (params.get("HouInfoFile")!=null && !(params.get("HouInfoFile").equals(""))){
//                            String [] imgArr=params.get("HouInfoFile").toString().split(",");
//                            for (String  img: imgArr){
//                                if (img!=null && !(img.equals(""))){
//                                    list.add(img);
//                                }
//                            }
//                        }
////                        list.add("http://pic.58.com/manage.yuefu.58.com/n_v1bkujjd2aw5xfmf3qzyeq_cdebc1e04c8f0db9.jpg");
////                        list.add("http://pic.58.com/manage.yuefu.58.com/n_v1bkujjd2aw5xfmf3qzyeq_cdebc1e04c8f0db9.jpg");
////                        list.add("http://pic.58.com/manage.yuefu.58.com/n_v1bkujjd2aw5xfmf3qzyeq_cdebc1e04c8f0db9.jpg");
////                        list.add("http://pic.58.com/manage.yuefu.58.com/n_v1bkujjd2aw5xfmf3qzyeq_cdebc1e04c8f0db9.jpg");
////                        list.add("http://pic.58.com/manage.yuefu.58.com/n_v1bkujjd2aw5xfmf3qzyeq_cdebc1e04c8f0db9.jpg");
////                        list.add("http://pic.58.com/manage.yuefu.58.com/n_v1bkujjd2aw5xfmf3qzyeq_cdebc1e04c8f0db9.jpg");
//                        dataMap.put("picUrlList", list);
//                        dataMap.put("rentType",InteSameCityUtil.ifOperaTypeTorentType(params.get("IfOperaType").toString()));//1.整套出租 2.单间出租
//                        dataMap.put("bedRoomNum",params.get("bedRoomNum"));//房屋户型-室例如（2室）：2
//                        dataMap.put("livingRoomNum",params.get("livingRoomNum"));//房屋户型-厅例如（1室）：1  可以为0
//                        dataMap.put("toiletNum",params.get("toiletNum"));//房屋户型-卫 例如（1卫）：1  可以为0
//                        dataMap.put("rentRoomArea",params.get("rentRoomArea"));//对于单间出租的，为出租间面积 对于整租的为房屋总面积 对于整租的为房屋总面积 例如：110
//                        dataMap.put("faceToType",InteSameCityUtil.checkFaceToType(params.get("IfTowards").toString()));//faceToType 60:东 61:南 62:西63:北
//                        dataMap.put("totalFloor",params.get("totalFloor"));//totalFloor
//                        dataMap.put("houseFloor",params.get("houseFloor"));//房间所在楼层
//                        // dataMap.put("featureTag","10");//房间所在楼层 (N)
//                        dataMap.put("detailPoint","71");//房屋配置，枚举值，可多选
//                        //        dataMap.put("servicePoint","91");//公寓配套服务，枚举值，可多选 (N)
//                        dataMap.put("monthRent",params.get("monthRent"));//月租金，以元为单位
//                        dataMap.put("rentStartDate","2015-12-31");//起租时间，格式yyyy-MM-dd
//                        dataMap.put("shortRent","0");//是否支持短租，枚举值0:不支持 1支持 (N)
//                        //        dataMap.put("shotRentCycle","10");//选择短租模式，此字段必填 (N)
//                        //        dataMap.put("shotRentPrice","10");//短租价格 (N)
//                        dataMap.put("cityName",params.get("cityName"));//所在城市 上海
//                        dataMap.put("countyName",params.get("countyName"));//所在区县 浦东
//                        dataMap.put("areaName",params.get("areaName"));//房屋所在商圈 高行
//                        dataMap.put("districtName",params.get("districtName"));//districtName 新高苑
//                        dataMap.put("street",params.get("street"));//房屋所在小区详细地址
//                        dataMap.put("address","8楼102");//房屋所在小区详细地址
//                        dataMap.put("houseDesc",params.get("Description"));//房源描述房间描述（50-500字以内）
//                        dataMap.put("xCoord",params.get("xCoord"));//经度
//                        dataMap.put("yCoord",params.get("yCoord"));//纬度
//                        dataMap.put("agentPhone","15703928852");//房管手机号
//                        dataMap.put("agentName","10");//房管员姓名
//                        //        dataMap.put("paymentMode","10");//支付方式 (N)
//                        //        dataMap.put("rentRequire","10");//入住要求 (N)
//                        //dataMap.put("hasLift ","1");//电梯：1 无电梯 2 有电梯 (N)
//                        Map<String,Object> sameShellResult;
//                        if (sameCityCount==0){//sameCityCount 0未发布 1已发布
//                            //是否是整租 0否 1是
//                            if (params.get("IfOperaType").toString().equals("1")){
//                                dataMap.put("outHouseId",params.get("HouId"));
//                            }else{
//                                //合租下才是必传字段
//                                dataMap.put("bedRoomType",InteSameCityUtil.checkBedRoomType(params.get("cod").toString()));//出租屋类型，枚举值。 出租屋类型，枚举值。
//                                dataMap.put("outHouseId",params.get("HouInfoId"));
//                            }
//                            //请求体
//                            Map<String,String> map=new HashMap<String,String>();
//                            //组装请求接口的map类型参数 转成json 然后生成加密字符串
//                            String rsaString= ThirdRSACoder.encrypt(JSON.toJSONString(dataMap),InteSameCityConfig.PRIVATE_KEY);
//                            String rsaString2=ThirdRSACoder.decrypt(rsaString,InteSameCityConfig.PUBLIIC_KEY);
//                            log.info("rsaString:"+rsaString);
//                            log.info("rsaString2:"+rsaString2);
//                            map.put("data",rsaString);
//                            //第一次发布房源到58
//                            sameShellResult=InteSameCityUtil.api_house_add(map);
//                            log.info("内部房源在58发布返回的参数:"+sameShellResult);
//                        }else{
//                            dataMap.put("bedRoomType",InteSameCityUtil.checkBedRoomType(params.get("cod").toString()));//出租屋类型，枚举值。 出租屋类型，枚举值。
//                            dataMap.put("houseId",params.get("stPrimaryKey"));
//                            //请求体
//                            Map<String,String> map=new HashMap<String,String>();
//                            //组装请求接口的map类型参数 转成json 然后生成加密字符串
//                            String rsaString= ThirdRSACoder.encrypt(JSON.toJSONString(dataMap),InteSameCityConfig.PRIVATE_KEY);
//                            String rsaString2=ThirdRSACoder.decrypt(rsaString,InteSameCityConfig.PUBLIIC_KEY);
//                            log.info("rsaString:"+rsaString);
//                            log.info("rsaString2:"+rsaString2);
//                            map.put("data",rsaString);
//                            //如果该房源在58平台已经发布的话就做修改操作
//                            sameShellResult=InteSameCityUtil.api_house_modify(map);
//                            log.info("修改内部房源在58的房源信息返回的参数:"+sameShellResult);
//                        }
//
//                        if(sameShellResult.get("code")!=null && sameShellResult.get("code").toString().equals("0")){
//                            Map<String,Object> sameSheMap=(Map<String,Object>)sameShellResult.get("result");
//                            rdHsMap.put("PrimaryStatus","1");//第三方上架状态 0 待上架 1可签约 2已签约
//                            rdHsMap.put("PrimaryKey",sameSheMap.get("houseId")) ;//58返回的房源编号
//                            rdHousingShelfMapper.addRdHs(rdHsMap);//新增内部房源在58平台的房源信息
//                            result.putSuccess("上架成功");
//                        }else{
//                            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
//                            result.putFailed("服务器繁忙");
//                        }
//                    }
//                }else{
//                    TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
//                    result.putFailed("服务器繁忙");
//                }
//            } catch (Exception e) {
//                e.printStackTrace();
//                TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
//            }
//        }
//        finally {
//            lock.unlock();
//        }
//        return result;
//    }



    /*
     *房源下架
     */
    @Transactional(rollbackFor = Exception.class)
    public JsonResult updateHousingHouInfoDown(Map<String,Object> params){
        JsonResult result=new JsonResult();
        /**
         * 加锁操作
         */
        lock.lock();
        try{
            try {
                if(params.get("HouInfoId")==null || params.get("sameCityCount")==null
                        || params.get("IfOperaType")==null || params.get("HouId")==null || params.get("sThoCount")==null){
                    return result.putFailed("参数不正确");
                }
                boolean ifsameCity=false;//是否要推送房源到58
                Integer sameCityCount=(Integer)params.get("sameCityCount");//58 是否已经发布
                Integer sThoCount=(Integer)params.get("sThoCount");//整租房源是否在58发布过
                //选中的第三方平台集合
                List<Integer> sheTypeList=(List<Integer>)params.get("SheTypeList");
                for (Integer sheType :sheTypeList){
                    //sheType 0  58同城 1 贝壳
                    if (sheType!=null && sheType==0){
                        ifsameCity=true;
                    }
                }
                params.put("State",0);//房源状态 0 可预销 1可签约 2已签约
                params.put("by", ContextUtils.getUserId());//操作人
                params.put("term", "2");// 更新端 Update端： 1 租客端 2市场部 3 工程部   4运营部   5财务部  6总经办 7发展部
                params.put("fnc",
                        this.getClass().getSimpleName() + "." + Thread.currentThread().getStackTrace()[1].getMethodName());// 创建Function名
                ParamsCommon.commonUpdateParms(params);
                //0合租 1整租
                if (params.get("IfOperaType").toString().equals("1")){
                    params.put("ifHouId","1");
                }
                //修改内部房源为下架
                Integer count=rdHousingInfoMapper.updateRdHi(params);
                //修改第三房源为下架
                params.put("PrimaryStatus","0");//第三方上架状态 0 待上架 1可签约 2已签约
                params.put("SheId",params.get("stSheId"));//58 第三方上架表主键
                Integer count2=rdHousingShelfMapper.upRdHs(params);
                if(count!=null && count>0){
                    if(ifsameCity==true && sameCityCount>0){
                        //如果58被选中就让房源在58那里下架s
                        Map<String,Object> dataMap=new HashMap<String,Object>();
                        dataMap.put("appId",InteSameCityConfig.APPID_TEST);
                        dataMap.put("houseId",new String[]{params.get("stPrimaryKey").toString()});//内部房源在58平台的唯一标识
                        dataMap.put("status","4000");//房屋修改状态，枚举值 3000 上线 4000:下线 5000:已出租
                        //请求体
                        Map<String,String> map=new HashMap<String,String>();
                        //组装请求接口的map类型参数 转成json 然后生成加密字符串
                        String rsaString=ThirdRSACoder.encrypt(JSON.toJSONString(dataMap),InteSameCityConfig.PRIVATE_KEY);
                        log.info("rsaString:"+rsaString);
                        log.info("rsaString2:"+ThirdRSACoder.decrypt(rsaString,InteSameCityConfig.PUBLIIC_KEY));
                        map.put("data",rsaString);
                        //请求58的修改房源状态接口
                        Map<String,Object> sameShellResult=InteSameCityUtil.api_house_info_get(map);
                        if (sameShellResult.get("code").toString().equals("0")){
                            //如果该房间的整租房源也在58上架的话，关联下架
                            if (params.get("IfOperaType").toString().equals("0") && sThoCount>0 && params.get("sThoPrimaryStatus").equals("1")){
                                dataMap.put("houseId",new String[]{params.get("stPrimaryKey").toString()});//内部房源在58平台的唯一标识
                                rsaString=ThirdRSACoder.encrypt(JSON.toJSONString(dataMap),InteSameCityConfig.PRIVATE_KEY);
                                log.info("rsaString:"+rsaString);
                                log.info("rsaString2:"+ThirdRSACoder.decrypt(rsaString,InteSameCityConfig.PUBLIIC_KEY));
                                map.put("data",rsaString);
                                Map<String,Object> sThoResult=InteSameCityUtil.api_house_info_get(map);
                                if (sThoResult.get("code").toString().equals("0")){
                                    result.putSuccess("下架成功");
                                }else{
                                    TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                                    result.putFailed("服务器繁忙");
                                }
                            }else{
                                result.putSuccess("下架成功");
                            }
                        }else{
                            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                            result.putFailed("服务器繁忙");
                        }
                    }
                    result.putSuccess("下架成功");
                }else{
                    TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                    result.putFailed("服务器繁忙");
                }
            } catch (Exception e) {
                e.printStackTrace();
                TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            }
        }
        finally {
            lock.unlock();
        }
        return result;
    }
    /**
     * 签约根据房源详表编号查询房源的配置 合租
     */
    public List<Map<String,Object>> getHouConListByHouConIdP(Map<String,Object> params){
        return rdHousingInfoMapper.getHouConListByHouConIdP(params);
    }
    /**
     * 签约根据房源编号查询房源的配置 整租
     */
    public List<Map<String,Object>> getHouConListByHouIdZ(Map<String,Object> params){
        return rdHousingInfoMapper.getHouConListByHouIdZ(params);
    }
    /**
     *签约根据房源详表编号查询房源的配置总数 合租
     */
    public Integer getHouConListCountByHouConIdP(Map<String,Object> params){
        return rdHousingInfoMapper.getHouConListCountByHouConIdP(params);
    }
    /**
     * 签约根据房源编号查询房源的配置总数 整租
     */
    public Integer getHouConListCountByHouIdZ(Map<String,Object> params){
        return rdHousingInfoMapper.getHouConListCountByHouIdZ(params);
    }
    /**
     * 查询盈利预测拆分间数的总和
     */
    public Integer getCountForHouInfo(){
        return rdHousingInfoMapper.getCountForHouInfo();
    }
    /**
     *运营部录入水电燃费时查询已经签约房源的信息
     */
    public List<Map<String,Object>> getHouInfoListForEwg(Map<String,Object> params){
        return rdHousingInfoMapper.getHouInfoListForEwg(params);
    }
    /*
     *运营部录入水电燃费时查询已经签约房源的信息总数
     */
    public Integer getHouInfoListCountForEwg(Map<String,Object> params){
        return rdHousingInfoMapper.getHouInfoListCountForEwg(params);
    }
    /**
     *运营部录入水电燃费时查询已经签约房源的信息
     */
    public List<Map<String,Object>> getHouInfoListForGmio(Map<String,Object> params){
        //拿到租客编号列表
        List<Map<String,Object>> list=(List<Map<String, Object>>) params.get("tenBillList");
        System.out.println("list："+list);
        List<Map<String,Object>> sysUserList=rdHousingInfoMapper.getSysUserIdForGmio(params);
        System.out.println("sysUserList:"+sysUserList);

        for (Map<String, Object> mmap : list) {
            if(mmap.get("HouInfoId")!=null) {
                for (Map<String, Object> zmap : sysUserList) {
                    if (zmap.get("HouInfoId")!=null){
                        if (MapUtils.getString(mmap, "HouInfoId").equals(MapUtils.getString(zmap, "HouInfoId"))) {
                            zmap.putAll(mmap);
                        }
                    }

                }
            }
        }
        //根据租客编号查询租客的信息
        Map<String,Object> map=new HashMap<String,Object>();
        map.put("TenantList",list);//租客的集合
        List<Map<String,Object>> tList=rdTenantMapper.getTenantBySysTenId(map);
        System.out.println("tListtListtListtList:"+tList);
        //遍历循环把租客的姓名放到集合中
        for (Map<String, Object> mmap : sysUserList) {
            if(mmap.get("TenId")!=null) {
                for (Map<String, Object> zmap : tList) {
                    if(zmap.get("TenId")!=null) {
                        if (MapUtils.getString(mmap, "TenId").equals(MapUtils.getString(zmap, "TenId"))) {
                            mmap.putAll(zmap);
                        }
                    }
                }
            }
        }
        //根据服务管家编号查询管家的信息

        map.put("sysUserList",sysUserList);//归属管家的集合

        JsonResult result=zzuulFeign.getSysUserBySysUserId(map);
        System.out.println("result:"+result);
        if (result.get("errorCode").equals("0")){
            Map<String,Object> zuulMap=(Map<String,Object>)result.get("result");
            List<Map<String,Object>> sList=(List<Map<String,Object>>)zuulMap.get("sysUserList");
            //遍历循环把服务管家的姓名放到集合中
            for (Map<String, Object> mmap : sysUserList) {
                if(mmap.get("SysUserId")!=null) {
                    for (Map<String, Object> zmap : sList) {
                        if (zmap.get("user_id")!=null){
                            if (MapUtils.getString(mmap, "SysUserId").equals(MapUtils.getString(zmap, "user_id"))) {
                                mmap.putAll(zmap);
                            }
                        }

                    }
                }
            }
        }
        System.out.println("返回给运营部的数据:"+sysUserList);
        return sysUserList;
    }

    /**
     *运营部录入水电燃费时查询已经签约房源的信息（如果勾选了市场部的筛选条件）
     */
    public JsonResult getHouInfoListForGmioTcmkt(Map<String,Object> params){
        Pager pager=new Pager();
        pager.setPageno(Integer.parseInt(params.get("pageno").toString()));
        pager.setPagesize(Integer.parseInt(params.get("pagesize").toString()));
        pager.setPagerNecessary(params, pager);
        PageUtils pageUtils = new PageUtils();
        String a="";
        if(params.get("ifOperaType")!=null){
            a=params.get("ifOperaType").toString();
        }
        if (a.equals("")) {//是否整租
            params.put("ifOperaList", null);
        }else{
            params.put("ifOperaList",  a.split(","));
        }
        JsonResult tcmktResult=new JsonResult();
        //拿到租客编号列表
        List<Map<String,Object>> list=(List<Map<String, Object>>) params.get("tenBillList");
        System.out.println("list:"+list);
        //服务秘书账单审核列表总数
        Integer count=rdHousingInfoMapper.getSysUserIdForGmioCount(params);
        if(count>0){
            List<Map<String,Object>> sysUserLists=rdHousingInfoMapper.getSysUserIdForGmio(params);
            for (Map<String, Object> mmap : list) {
                if(mmap.get("HouInfoId")!=null) {
                    for (Map<String, Object> zmap : sysUserLists) {
                        if (zmap.get("HouInfoId")!=null){
                            if (MapUtils.getString(mmap, "HouInfoId").equals(MapUtils.getString(zmap, "HouInfoId"))) {
                                //zmap.putAll(mmap);
                                mmap.putAll(zmap);
                            }
                        }

                    }
                }
            }
            //根据租客编号查询租客的信息
            Map<String,Object> map=new HashMap<String,Object>();

           List<Map<String,Object>> sysUserList = list;
            map.put("TenantList",sysUserList);//租客的集合
            List<Map<String,Object>> tList=rdTenantMapper.getTenantBySysTenId(map);
            //遍历循环把租客的姓名放到集合中
            for (Map<String, Object> mmap : sysUserList) {
                if(mmap.get("TenId")!=null) {
                    for (Map<String, Object> zmap : tList) {
                        if(zmap.get("TenId")!=null) {
                            if (MapUtils.getString(mmap, "TenId").equals(MapUtils.getString(zmap, "TenId"))) {
                                mmap.putAll(zmap);
                            }
                        }
                    }
                }
            }
            //根据服务管家编号查询管家的信息
            map.put("sysUserList",sysUserList);//归属管家的集合
            JsonResult result=zzuulFeign.getSysUserBySysUserId(map);
            if (result.get("errorCode").equals("0")){
                Map<String,Object> zuulMap=(Map<String,Object>)result.get("result");
                List<Map<String,Object>> sList=(List<Map<String,Object>>)zuulMap.get("sysUserList");
                //遍历循环把服务管家的姓名放到集合中
                for (Map<String, Object> mmap : sysUserList) {
                    if(mmap.get("SysUserId")!=null) {
                        for (Map<String, Object> zmap : sList) {
                            if (zmap.get("user_id")!=null){
                                if (MapUtils.getString(mmap, "SysUserId").equals(MapUtils.getString(zmap, "user_id"))) {
                                    mmap.putAll(zmap);
                                }
                            }

                        }
                    }
                }

            }
            tcmktResult= pageUtils.getJsonResult(sysUserList, params, count);
        }else{
            tcmktResult=pageUtils.getJsonResult(new ArrayList<Map<String,Object>>(), params, count);
        }
        return   tcmktResult;
    }
    /**
     * 运营部租后主管退租账单房间列表
     */
    public Map<String,Object> getHouInfoListForDbill(Map<String,Object> params){
        //返回给运营部的数据
        Map<String,Object> marktmap=new HashMap<String,Object>();
        List<Map<String,Object>> list=rdHousingInfoMapper.getHouInfoListForDbill(params);
        /*查询租客的信息*/
        List<Map<String,Object>> tList=rdTenantMapper.getTenantListByTenId(params);
        System.out.println("查询到的租客信息:"+tList);
        //把租客信息返回给运营部
        marktmap.put("tList",tList);
        //保存服务管家的员工编号
        List<String> idList=new ArrayList<String>();
        for (Map<String,Object> map:list){
            if(map.get("SysUserId")!=null && !map.get("SysUserId").equals("")){
                idList.add(map.get("SysUserId").toString());
            }
        }
        System.out.println("list:"+list);
        System.out.println("idList:"+idList);
        if(idList.size()>0) {
            //查询网关的服务管家的姓名
            JsonResult zuulMap = zzuulFeign.getButlerName(idList);
            List<Map<String, Object>> zuulList = (List<Map<String, Object>>) zuulMap.get("result");
            for (Map<String, Object> map : zuulList) {
                for (Map<String, Object> map2 : list) {
                    if (MapUtils.getString(map, "user_id").equals(MapUtils.getString(map2, "SysUserId"))) {
                        map2.putAll(map);
                    }
                }
            }
        }
        marktmap.put("list",list);
        return marktmap;
    }
    /*
     *运营部租后主管退租账单房间列表总数
     */
    public Integer getHouInfoListCountForDbill(Map<String,Object> params){
        return rdHousingInfoMapper.getHouInfoListCountForDbill(params);
    }
    /**
     * 租赁顾问输入房源编号创建带看工单
     */
    public List<Map<String,Object>> getHousingInfoIdList(Map<String,Object> params){
        return rdHousingInfoMapper.getHousingInfoIdList(params);
    }
    /*
     *运营部根据房源编号查询房源的合同截止日期和合同编号
     */
    public Map<String,Object> getPactInfoByHouInfoId (Map<String,Object> params){
        return rdHousingInfoMapper.getPactInfoByHouInfoId(params);
    }
    /*
     *运营部根据房源详表编号查询该房源签约业主的所有合同
     */
    public List<Map<String,Object>> getPactIdListByHouInfoId (Map<String,Object> params){
        return rdHousingInfoMapper.getPactIdListByHouInfoId(params);
    }

    /**
     *运营部租后主管查询账单审核列表
     */
    public Map<String,Object> getHouInfoListForDi(Map<String,Object> params){
        Map<String,Object> markmap=new HashMap<String,Object>();
        //拿到租客编号列表
        List<Map<String,Object>> list=(List<Map<String, Object>>) params.get("tenBillList");
        List<Map<String,Object>> sysUserList=rdHousingInfoMapper.getSysUserIdForDiGmio(params);
        for (Map<String, Object> mmap : list) {
            if(mmap.get("HouId")!=null) {
                for (Map<String, Object> zmap : sysUserList) {
                    if (zmap.get("HouId")!=null){
                        if (MapUtils.getString(mmap, "HouId").equals(MapUtils.getString(zmap, "HouId"))) {
                            zmap.put("TenId",mmap.get("TenId"));
                            zmap.put("Create",mmap.get("Create"));
                        }
                    }

                }
            }
        }
        System.out.println("sysUserList:"+sysUserList);
        //根据租客编号查询租客的信息
        Map<String,Object> map=new HashMap<String,Object>();
        map.put("TenantList",sysUserList);//租客的集合
        List<Map<String,Object>> tList=rdTenantMapper.getTenantBySysTenId(map);
        System.out.println("tList:"+tList);
        //遍历循环把租客的姓名放到集合中
        for (Map<String, Object> mmap : sysUserList) {
            if(mmap.get("TenId")!=null) {
                for (Map<String, Object> zmap : tList) {
                    if(zmap.get("TenId")!=null) {
                        if (MapUtils.getString(mmap, "TenId").equals(MapUtils.getString(zmap, "TenId"))) {
                            mmap.putAll(zmap);
                        }
                    }
                }
            }
        }
        //根据服务管家编号查询管家的信息
        map.put("sysUserList",sysUserList);//归属管家的集合
        map.put("createList",sysUserList);//查询创建人的信息
        JsonResult result=zzuulFeign.getSysUserBySysUserId(map);
        if (result.get("errorCode").equals("0")){
            Map<String,Object> zuulMap=(Map<String,Object>)result.get("result");
            List<Map<String,Object>> sList=(List<Map<String,Object>>)zuulMap.get("sysUserList");
            List<Map<String,Object>> cList=(List<Map<String,Object>>)zuulMap.get("createList");
            System.out.println("clist:"+cList);
            //遍历循环把服务管家的姓名放到集合中
            for (Map<String, Object> mmap : sysUserList) {
                if(mmap.get("SysUserId")!=null) {
                    for (Map<String, Object> zmap : sList) {
                        if (zmap.get("user_id")!=null){
                            if (MapUtils.getString(mmap, "SysUserId").equals(MapUtils.getString(zmap, "user_id"))) {
                                mmap.putAll(zmap);
                            }
                        }
                    }
                }
            }
            //遍历循环把账单创建人放到集合中
            for (Map<String, Object> mmap : sysUserList) {
                if(mmap.get("Create")!=null) {
                    for (Map<String, Object> zmap : cList) {
                        if (zmap.get("CreId")!=null){
                            if (MapUtils.getString(mmap, "Create").equals(MapUtils.getString(zmap, "CreId"))) {
                                mmap.putAll(zmap);
                            }
                        }
                    }
                }
            }

        }
        markmap.put("dataList",sysUserList);
        System.out.println("返回给运营部的数据:"+markmap);
        return   markmap;
    }
    /**
     * 服务管家根据房源编号查询该房源所签署的合同信息
     */
    public JsonResult getHouPactByHouInfoId(Map<String,Object> params){
        JsonResult result=new JsonResult();
        Map<String,Object> map=rdHousingInfoMapper.getHouPactByHouInfoId(params);
        if (map.get("StartTime")!=null && map.get("EndTime")!=null){
            Integer monthCount=DateUtils.getMonthSpace(map.get("EndTime").toString()
                    ,map.get("StartTime").toString(),"yyyy-MM-dd");

            map.put("monthCount",Math.abs(monthCount));//签约周期
            result.put(map);
        }else{
            result.putFailed("服务器繁忙");
        }
        return result;
    }
    /**
     * 运营部服务管家查询办理居住证的房源信息
     */
    public List<Map<String,Object>> getHoulivecardList(Map<String,Object> params){
        return rdHousingInfoMapper.getHoulivecardList(params);
    }
    /**
     * 租客端查询临时账单列表
     */
    public List<Map<String,Object>> getHouTemporaryList(Map<String,Object> params){
        return rdHousingInfoMapper.getHouTemporaryList(params);
    }
    /**
     * 根据房源详表编号查询房源的地址信息（运营助理给员工发送临时密码）
     */
    public JsonResult getRdHousingInfoListByHouInfoId(Map<String,Object> params){
        JsonResult result=new JsonResult();
        //根据房源详表编号查询房源的地址信息
        List<Map<String,Object>> list=rdHousingInfoMapper.getRdHousingInfoListByHouInfoId(params);
        if (list!=null){
            result.put(list);
        }else{
            result.putFailed("服务器繁忙");
        }
        return result;
    }

}
